type runtime._type

101 uses

	runtime (current package)
		alg.go#L145: func typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L197: func reflect_typehash(t *_type, p unsafe.Pointer, h uintptr) uintptr {
		alg.go#L244: func efaceeq(t *_type, x, y unsafe.Pointer) bool {
		arena.go#L111: 	t := (*_type)(efaceOf(&typ).data)
		arena.go#L267: func (a *userArena) new(typ *_type) unsafe.Pointer {
		arena.go#L355: func (a *userArena) alloc(typ *_type, cap int) unsafe.Pointer {
		arena.go#L437: func (s *mspan) userArenaNextFree(typ *_type, cap int) unsafe.Pointer {
		arena.go#L528: func userArenaHeapBitsSetType(typ *_type, ptr unsafe.Pointer, base uintptr) {
		arena.go#L622: func userArenaHeapBitsSetSliceType(typ *_type, n int, ptr unsafe.Pointer, base uintptr) {
		cgocall.go#L461: func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
		cgocall.go#L497: 		it := *(**_type)(p)
		cgocheck.go#L79: func cgoCheckMemmove(typ *_type, dst, src unsafe.Pointer) {
		cgocheck.go#L91: func cgoCheckMemmove2(typ *_type, dst, src unsafe.Pointer, off, size uintptr) {
		cgocheck.go#L112: func cgoCheckSliceCopy(typ *_type, dst, src unsafe.Pointer, n int) {
		cgocheck.go#L135: func cgoCheckTypedBlock(typ *_type, src unsafe.Pointer, off, size uintptr) {
		cgocheck.go#L235: func cgoCheckUsingType(typ *_type, src unsafe.Pointer, off, size uintptr) {
		chan.go#L39: 	elemtype *_type // element type
		chan.go#L335: func sendDirect(t *_type, sg *sudog, src unsafe.Pointer) {
		chan.go#L348: func recvDirect(t *_type, sg *sudog, dst unsafe.Pointer) {
		checkptr.go#L9: func checkptrAlignment(p unsafe.Pointer, elem *_type, n uintptr) {
		error.go#L22: 	_interface    *_type
		error.go#L23: 	concrete      *_type
		error.go#L24: 	asserted      *_type
		heapdump.go#L119: 	t [typeCacheAssoc]*_type
		heapdump.go#L164: func dumptype(t *_type) {
		heapdump.go#L225: func dumpfinalizer(obj unsafe.Pointer, fn *funcval, fint *_type, ot *ptrtype) {
		heapdump.go#L427: func finq_callback(fn *funcval, obj unsafe.Pointer, nret uintptr, fint *_type, ot *ptrtype) {
		iface.go#L29: func itabHashFunc(inter *interfacetype, typ *_type) uintptr {
		iface.go#L34: func getitab(inter *interfacetype, typ *_type, canfail bool) *itab {
		iface.go#L97: func (t *itabTableType) find(inter *interfacetype, typ *_type) *itab {
		iface.go#L262: func panicdottypeE(have, want, iface *_type) {
		iface.go#L268: func panicdottypeI(have *itab, want, iface *_type) {
		iface.go#L269: 	var t *_type
		iface.go#L278: func panicnildottype(want *_type) {
		iface.go#L306: 	uint16Type *_type = efaceOf(&uint16Eface)._type
		iface.go#L307: 	uint32Type *_type = efaceOf(&uint32Eface)._type
		iface.go#L308: 	uint64Type *_type = efaceOf(&uint64Eface)._type
		iface.go#L309: 	stringType *_type = efaceOf(&stringEface)._type
		iface.go#L310: 	sliceType  *_type = efaceOf(&sliceEface)._type
		iface.go#L322: func convT(t *_type, v unsafe.Pointer) unsafe.Pointer {
		iface.go#L336: func convTnoptr(t *_type, v unsafe.Pointer) unsafe.Pointer {
		iface.go#L449: func assertE2I(inter *interfacetype, t *_type) *itab {
		malloc.go#L952: func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
		malloc.go#L1327: func newobject(typ *_type) unsafe.Pointer {
		malloc.go#L1332: func reflect_unsafe_New(typ *_type) unsafe.Pointer {
		malloc.go#L1337: func reflectlite_unsafe_New(typ *_type) unsafe.Pointer {
		malloc.go#L1342: func newarray(typ *_type, n int) unsafe.Pointer {
		malloc.go#L1354: func reflect_unsafe_NewArray(typ *_type, n int) unsafe.Pointer {
		mbarrier.go#L178: func wbZero(typ *_type, dst unsafe.Pointer) {
		mbarrier.go#L188: func wbMove(typ *_type, dst, src unsafe.Pointer) {
		mbarrier.go#L193: func reflect_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
		mbarrier.go#L210: func reflectlite_typedmemmove(typ *_type, dst, src unsafe.Pointer) {
		mbarrier.go#L224: func reflectcallmove(typ *_type, dst, src unsafe.Pointer, size uintptr, regs *abi.RegArgs) {
		mbarrier.go#L239: func typedslicecopy(typ *_type, dstPtr unsafe.Pointer, dstLen int, srcPtr unsafe.Pointer, srcLen int) int {
		mbarrier.go#L291: func reflect_typedslicecopy(elemType *_type, dst, src slice) int {
		mbarrier.go#L309: func typedmemclr(typ *_type, ptr unsafe.Pointer) {
		mbarrier.go#L317: func reflect_typedmemclr(typ *_type, ptr unsafe.Pointer) {
		mbarrier.go#L322: func reflect_typedmemclrpartial(typ *_type, ptr unsafe.Pointer, off, size uintptr) {
		mbarrier.go#L330: func reflect_typedarrayclear(typ *_type, ptr unsafe.Pointer, len int) {
		mbitmap.go#L688: func typeBitsBulkBarrier(typ *_type, dst, src, size uintptr) {
		mbitmap.go#L946: func heapBitsSetType(x, size, dataSize uintptr, typ *_type) {
		mfinal.go#L56: 	fint *_type         // type of first argument of fn
		mfinal.go#L94: func queuefinalizer(p unsafe.Pointer, fn *funcval, nret uintptr, fint *_type, ot *ptrtype) {
		mfinal.go#L144: func iterate_finq(callback func(*funcval, unsafe.Pointer, uintptr, *_type, *ptrtype)) {
		mheap.go#L1937: 	fint    *_type   // May be a heap pointer, but always live.
		mheap.go#L1942: func addfinalizer(p unsafe.Pointer, f *funcval, nret uintptr, fint *_type, ot *ptrtype) bool {
		mprof.go#L1226: func tracealloc(p unsafe.Pointer, size uintptr, typ *_type) {
		netpoll.go#L693: 	pdType  *_type = efaceOf(&pdEface)._type
		plugin.go#L82: 		t := toRType((*_type)(unsafe.Pointer(md.types))).typeOff(ptab.typ) // TODO can this stack of conversions be simpler?
		race0.go#L19: func raceReadObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr)  { throw("race") }
		race0.go#L20: func raceWriteObjectPC(t *_type, addr unsafe.Pointer, callerpc, pc uintptr) { throw("race") }
		runtime1.go#L611: 	return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
		runtime1.go#L618: 	return toRType((*_type)(rtype)).textOff(textOff(off))
		runtime1.go#L633: 	return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
		runtime2.go#L210: 	_type *_type
		runtime2.go#L953: 	_type *_type
		slice.go#L38: func makeslicecopy(et *_type, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer {
		slice.go#L88: func makeslice(et *_type, len, cap int) unsafe.Pointer {
		slice.go#L106: func makeslice64(et *_type, len64, cap64 int64) unsafe.Pointer {
		slice.go#L157: func growslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice {
		slice.go#L287: func reflect_growslice(et *_type, old slice, num int) slice {
		stubs.go#L295: func reflectcall(stackArgsType *_type, fn, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		symtab.go#L378: 	typemap map[typeOff]*_type // offset to *_rtype in previous module
		symtab.go#L410: var pinnedTypemaps []map[typeOff]*_type
		type.go#L18: type _type = abi.Type
		type.go#L143: func resolveTypeOff(ptrInModule unsafe.Pointer, off typeOff) *_type {
		type.go#L168: 		return (*_type)(res)
		type.go#L178: 	return (*_type)(unsafe.Pointer(res))
		type.go#L181: func (t rtype) typeOff(off typeOff) *_type {
		type.go#L258: 	typehash := make(map[uint32][]*_type, len(firstmoduledata.typelinks))
		type.go#L266: 			var t *_type
		type.go#L268: 				t = (*_type)(unsafe.Pointer(prev.types + uintptr(tl)))
		type.go#L286: 			tm := make(map[typeOff]*_type, len(md.typelinks))
		type.go#L290: 				t := (*_type)(unsafe.Pointer(md.types + uintptr(tl)))
		type.go#L307: 	t1 *_type
		type.go#L308: 	t2 *_type
		type.go#L327: func typesEqual(t, v *_type, seen map[_typePair]struct{}) bool {
		typekind.go#L41: func isDirectIface(t *_type) bool {
		unsafe.go#L53: func unsafeslice(et *_type, ptr unsafe.Pointer, len int) {
		unsafe.go#L74: func unsafeslice64(et *_type, ptr unsafe.Pointer, len64 int64) {
		unsafe.go#L82: func unsafeslicecheckptr(et *_type, ptr unsafe.Pointer, len64 int64) {